package com.markerhub.controller;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.markerhub.common.lang.Result;
import com.markerhub.entity.SysPerformanceLog;
import com.markerhub.service.SysPerformanceLogService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.access.prepost.PreAuthorize;

import org.springframework.web.bind.annotation.*;


import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.time.ZonedDateTime;

/**
 * 性能日志Controller
 */
@Api(tags = "性能日志管理")
@RestController
@RequestMapping("/api/sys-performance-log")
public class SysPerformanceLogController extends BaseController {

    @Autowired
    private SysPerformanceLogService sysPerformanceLogService;

    /**
     * 获取性能日志列表 - 分页
     */
    @PreAuthorize("hasAuthority('sys:performance-log:list')")
    @ApiOperation(value = "获取性能日志列表", notes = "获取所有性能日志信息，支持分页查询")
    @GetMapping("/list")
    public Result list(@RequestParam(required = false) Long id,
                      @RequestParam(required = false) Date startTime,
                      @RequestParam(required = false) Date endTime) {
        // 构建查询条件
        QueryWrapper<SysPerformanceLog> queryWrapper = new QueryWrapper<>();
        if (id != null) {
            queryWrapper.eq("id", id);
        }
        if (startTime != null) {
            queryWrapper.ge("created", startTime);
        }
        if (endTime != null) {
            queryWrapper.le("created", endTime);
        }
        // 按创建时间倒序排序
        queryWrapper.orderByDesc("created");
        
        // 执行分页查询
        Page<SysPerformanceLog> page = sysPerformanceLogService.page(getPage(), queryWrapper);
        return Result.succ(200, "获取系统性能监控日志列表成功", page);
    }

    /**
     * 查询性能日志 - 分页
     */
    @PreAuthorize("hasAuthority('sys:performance-log:list')")
    @ApiOperation(value = "查询性能日志", notes = "根据条件查询性能日志")
    @GetMapping("/query")
    public Result query(@RequestParam(required = false) Long id,
                       @RequestParam(required = false) Date startTime,
                       @RequestParam(required = false) Date endTime) {
        // 使用BaseController中的getPage()方法获取分页参数
        Page<SysPerformanceLog> page = getPage();
        // 构建查询条件
        QueryWrapper<SysPerformanceLog> wrapper = new QueryWrapper<>();
        if (id != null) {
            wrapper.eq("id", id);
        }
        if (startTime != null) {
            wrapper.ge("created", startTime);
        }
        if (endTime != null) {
            wrapper.le("created", endTime);
        }
        // 按创建时间倒序排序
        wrapper.orderByDesc("created");
        // 执行分页查询
        Page<SysPerformanceLog> pageData = sysPerformanceLogService.page(page, wrapper);
        return Result.succ(200, "查询系统性能监控日志成功", pageData);
    }

    /**
     * 根据ID获取系统性能监控日志信息
     */
    @PreAuthorize("hasAuthority('sys:performance-log:list')")
    @ApiOperation(value = "获取性能日志详情", notes = "根据ID获取系统性能监控日志详细信息")
    @GetMapping("/detail/{id}")
    public Result detail(@PathVariable Long id) {
        SysPerformanceLog log = sysPerformanceLogService.getById(id);
        return Result.succ(200, "获取系统性能监控日志信息成功", log);
    }

    /**
     * 删除系统性能监控日志（单个）
     */
    @PreAuthorize("hasAuthority('sys:performance-log:delete')")
    @ApiOperation(value = "删除性能日志", notes = "根据ID删除单个系统性能监控日志")
    @DeleteMapping("/delete/{id}")
    public Result delete(@PathVariable Long id) {
        boolean deleted = sysPerformanceLogService.removeById(id);
        return deleted ? Result.succ(200, "删除系统性能监控日志成功", null) : Result.fail("删除系统性能监控日志失败");
    }
    


    /**
     * 清空性能日志 - 按时间范围
     */
    @PreAuthorize("hasAuthority('sys:performance-log:clear')")
    @ApiOperation(value = "清空性能日志", notes = "按时间范围清空性能日志")
    @DeleteMapping("/clear")
    public Result clear(@RequestParam String startTime, @RequestParam String endTime) {
        try {
            // 验证参数
            if (startTime == null || startTime.trim().isEmpty()) {
                return Result.fail("开始时间不能为空");
            }
            if (endTime == null || endTime.trim().isEmpty()) {
                return Result.fail("结束时间不能为空");
            }
            
            // 构建查询条件
            QueryWrapper<SysPerformanceLog> queryWrapper = new QueryWrapper<>();
            
            // 使用更简单可靠的日期解析方式
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");
            try {
                // 尝试解析ISO格式
                Date startDate = sdf.parse(startTime);
                Date endDate = sdf.parse(endTime);
                
                // 设置查询条件
                queryWrapper.ge("created", startDate);
                queryWrapper.le("created", endDate);
                
                // 添加日志记录
                System.out.println("清空性能日志：开始时间=" + startDate + "，结束时间=" + endDate);
                
            } catch (ParseException e) {
                // 如果ISO格式解析失败，尝试使用其他格式
                try {
                    SimpleDateFormat altSdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                    Date startDate = altSdf.parse(startTime);
                    Date endDate = altSdf.parse(endTime);
                    
                    queryWrapper.ge("created", startDate);
                    queryWrapper.le("created", endDate);
                    
                    System.out.println("清空性能日志（备用格式）：开始时间=" + startDate + "，结束时间=" + endDate);
                } catch (ParseException ex) {
                    // 记录详细错误信息
                    System.err.println("日期格式解析失败，开始时间：" + startTime + "，结束时间：" + endTime);
                    return Result.fail("日期格式错误，请使用ISO格式(yyyy-MM-dd'T'HH:mm:ss.SSS'Z')或标准格式(yyyy-MM-dd HH:mm:ss)");
                }
            }
            
            // 先查询符合条件的记录数
            long count = sysPerformanceLogService.count(queryWrapper);
            System.out.println("符合条件的日志记录数：" + count);
            
            if (count == 0) {
                return Result.succ(200, "没有找到符合条件的性能日志记录", null);
            }
            
            // 执行删除
            boolean removeResult = sysPerformanceLogService.remove(queryWrapper);
            
            if (removeResult) {
                System.out.println("性能日志清空成功，删除了" + count + "条记录");
                return Result.succ(200, "性能日志清空成功，删除了" + count + "条记录", null);
            } else {
                System.err.println("性能日志清空失败");
                return Result.fail("性能日志清空失败");
            }
        } catch (Exception e) {
            // 捕获所有异常并记录详细信息
            System.err.println("清空性能日志时发生异常：" + e.getMessage());
            e.printStackTrace();
            return Result.fail("操作失败：" + e.getMessage());
        }
    }
    
    /**
     * 性能分析
     */
    @PreAuthorize("hasAuthority('sys:performance-log:list')")
    @ApiOperation(value = "性能分析", notes = "对性能日志进行分析统计")
    @GetMapping("/analyze")
    public Result analyze(@RequestParam(required = false) String startTime, @RequestParam(required = false) String endTime) {
        try {
            // 构建查询条件
            QueryWrapper<SysPerformanceLog> queryWrapper = new QueryWrapper<>();
            
            // 按时间范围查询
            if (startTime != null && !startTime.isEmpty()) {
                // 使用ZonedDateTime解析带时区的ISO格式时间
                ZonedDateTime startZonedDateTime = ZonedDateTime.parse(startTime);
                Date startDate = Date.from(startZonedDateTime.toInstant());
                queryWrapper.ge("created", startDate);
            }
            
            if (endTime != null && !endTime.isEmpty()) {
                // 使用ZonedDateTime解析带时区的ISO格式时间
                ZonedDateTime endZonedDateTime = ZonedDateTime.parse(endTime);
                Date endDate = Date.from(endZonedDateTime.toInstant());
                queryWrapper.le("created", endDate);
            }
            
            // 获取所有符合条件的性能日志
            List<SysPerformanceLog> logs = sysPerformanceLogService.list(queryWrapper);
            
            // 简单的性能分析统计
            if (logs.isEmpty()) {
                return Result.succ(200, "暂无性能数据", null);
            }
            
            // 计算统计信息
            long totalCount = logs.size();
            // 使用responseTime字段替代costTime，并注意数据类型转换
            long slowCount = logs.stream().filter(log -> log.getResponseTime().doubleValue() > 1000).count(); // 超过1秒的慢请求
            double avgCostTime = logs.stream().mapToDouble(log -> log.getResponseTime().doubleValue()).average().orElse(0);
            double maxCostTime = logs.stream().mapToDouble(log -> log.getResponseTime().doubleValue()).max().orElse(0);
            double minCostTime = logs.stream().mapToDouble(log -> log.getResponseTime().doubleValue()).min().orElse(0);
            
            // 返回分析结果 - 使用Java 8兼容的HashMap实现
            Map<String, Double> result = new HashMap<>();
            result.put("totalCount", (double)totalCount);
            result.put("slowCount", (double)slowCount);
            result.put("avgCostTime", avgCostTime);
            result.put("maxCostTime", maxCostTime);
            result.put("minCostTime", minCostTime);
            return Result.succ(200, "性能分析成功", result);
        } catch (Exception e) {
            // 捕获时间解析异常，返回友好错误信息
            return Result.fail("时间格式错误，请使用ISO格式（如：2023-01-01T00:00:00Z）" + e.getMessage());
        }
    }
}